package com.culturalCenter.dataCenter.Utils;

import com.culturalCenter.dataCenter.customEntity.user.CustomUserPointChangeCount;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;

/**
 * @author ISMC
 * @since 2020/9/10 17:06
 */
public class MathUtil {

    /**
     * 给定最大最小值，取这区间内一个随机数
     *
     * @param min
     * @param max
     *
     * @return
     */
    public static int getRandomNumber(int min, int max) {
        Random random = new Random();
        return random.nextInt(max) % (max - min + 1) + min;
    }

    /**
     * 计算列表中的比率（使总和为100）
     */
    public static List<CustomUserPointChangeCount> calculateRate(List<CustomUserPointChangeCount> userPointChangeCountList) {
        if (userPointChangeCountList != null && userPointChangeCountList.size() > 0) {
            Integer sum = 0, rateInt;
            /*for (int i = 0; i < userPointChangeCountList.size(); i++) {
                CustomUserPointChangeCount customUserPointChangeCount = userPointChangeCountList.get(i);
                if (i != userPointChangeCountList.size() - 1) {
                    rateInt = Math.round((float) customUserPointChangeCount.getRate().doubleValue());
                } else {
                    rateInt = 100 - sum;
                }
                customUserPointChangeCount.setRateInt(rateInt);
                sum += rateInt;
            }*/
            List<Double> decimalList = new ArrayList<>();
            for (CustomUserPointChangeCount customUserPointChangeCount : userPointChangeCountList) {
                Double rateDouble = customUserPointChangeCount.getRate();
                rateInt = rateDouble.intValue();
                customUserPointChangeCount.setRateInt(rateInt);
                decimalList.add(rateDouble - rateInt);
                sum = sum + rateInt;
            }
            List<Double> decimalListSort = decimalList.stream().distinct().sorted(Comparator.comparing(Double::doubleValue).reversed()).collect(Collectors.toList());
            flag:
            for (Double decimal : decimalListSort) {
                if (sum < 100) {
                    int index = decimalList.indexOf(decimal);
                    int endIndex = decimalList.lastIndexOf(decimal);
                    if (index != endIndex) {
                        while (index != endIndex + 1) {
                            if (decimalList.get(index).doubleValue() == decimal.doubleValue()) {
                                rateInt = userPointChangeCountList.get(index).getRateInt();
                                userPointChangeCountList.get(index).setRateInt(rateInt + 1);
                                sum++;
                                if (sum == 100) {
                                    break flag;
                                }
                            }
                            index++;
                        }
                    } else {
                        rateInt = userPointChangeCountList.get(index).getRateInt();
                        userPointChangeCountList.get(index).setRateInt(rateInt + 1);
                        sum++;
                    }
                } else {
                    break;
                }

            }
        }
        return userPointChangeCountList;
    }

    /**
     * 给定一个精度值，计算某一项在一串数据中占据的百分比，确保百分比总和是1（100%）
     * <p>
     * 使用最大余额法
     *
     * @param {Array.} valueList a list of all data 一列数据
     * @param {number} idx index of the data to be processed in valueList 索引值（数组下标）
     * @param {number} precision integer number showing digits of precision 精度值
     *
     * @return {number} percent ranging from 0 to 100 返回百分比从0到100
     */

    public void getPercentWithPrecision(int[] valueList, int idx, int precision) {
//
//        if (!valueList[idx]) {
//
//            return 0
//
//    }
//
//        var sum = valueList.reduce(function (acc, val) {
//
//            return acc + (isNaN(val) ?0 : val)
//
//        }, 0)
//
//        if (sum ===0) {
//
//            return 0
//
//    }
//
//        console.log('sum', sum)
//
//// sum 9
//
//    var digits = Math.pow(10, precision)// digits 100
//
//    console.log('digits', digits)
//
//        var votesPerQuota = valueList.map(function (val) {
//
//            return (isNaN(val) ?0 : val) / sum * digits *100 // 扩大比例，这样可以确保整数部分是已经确定的议席配额，小数部分是余额
//
//    })
//
//        console.log('votesPerQuota', votesPerQuota)
//
//// votesPerQuota [ 2222.222222222222, 4444.444444444444, 3333.333333333333 ] 每一个项获得的议席配额，整数部分是已经确定的议席配额，小数部分是余额
//
//    var targetSeats = digits *100 // targetSeats 10000 全部的议席
//
//    console.log('targetSeats', targetSeats)
//
//        var seats = votesPerQuota.map(function (votes) {
//
//// Assign automatic seats.
//
//        return Math.floor(votes)
//
//        })
//
//        console.log('seats', seats)
//
//// seats [ 2222, 4444, 3333 ] 获取配额的整数部分
//
//    var currentSum = seats.reduce(function (acc, val) {
//
//            return acc + val
//
//        }, 0)
//
//        console.log('currentSum', currentSum)
//
//// 9999 表示已经配额了9999个议席，还剩下一个议席
//
//    var remainder = votesPerQuota.map(function (votes, idx) {
//
//            return votes - seats[idx]
//
//        })
//
//        console.log('remainder', remainder)
//
//// [ 0.2222222222221717, 0.4444444444443434, 0.33333333333303017 ]得到每一项的余额
//
//// Has remainding votes. 如果还有剩余的坐席就继续分配
//
//    while (currentSum < targetSeats) {
//
//// Find next largest remainder. 找到下一个最大的余额
//
//        var max = Number.NEGATIVE_INFINITY
//
//            var maxId =null
//
//        for (var i =0, len = remainder.length; i < len; ++i) {
//
//                if (remainder[i] > max) {
//
//                    max = remainder[i]
//
//                    maxId = i
//
//                }
//
//            }
//
//// max: 0.4444444444443434, maxId 1
//
//// Add a vote to max remainder.
//
//        ++seats[maxId]// 第二项，即4的占比的坐席增加1
//
//        remainder[maxId] =0
//
//        ++currentSum// 总的已分配的坐席数也加1
//
//    }
//
//        return seats[idx] / digits
//
//
    }

}
